Rock fragmentation analysis system

ABSTRACT

A rock fragmentation analysis system is provided for analyzing blasted rock (or other fragmented particles) to assess quality of a blast for efficient processing of subsequent operations in a mine, a quarry, etc. The system includes a hardware system and an image processing system. The hardware system includes a camera and a lighting system. The lighting system illuminates an area of the mine, quarry, etc. where a load haul dump (LHD) vehicle passes through. Once the LHD vehicle passes through the illuminated area, the camera provides video signals of scoop-top view images of the LHD vehicle to the image processing system via known communication means, such as hard-wired and wireless. The image processing system receives the video signals, captures the scoop-top view images, evaluates the images for subsequent fragmentation analysis, and performs the rock fragmentation analysis. The image processing system performs these functions using several software modules. Two such software modules are the Fragmentation Scanning (FragScan™) and the Fragmentation Analysis (FragAnalysis™) software modules. The FragScan software module scans the video signals until it captures a valid image for analysis by the FragAnalysis software module. Once the FragScan triggers on the image, a raw image and other details corresponding to the captured image are buffered for subsequent rock fragmentation analysis by the FragAnalysis software module. The rock fragmentation analysis is designed to estimate the major diameter of each rock visible in the image. The overall size distribution of the rocks in the image is output by the FragAnalysis software module, and the corresponding input image and the binary blob image, i.e., the processed image, are stored by the image processing system.

TECHNICAL FIELD

[0001] The instant invention relates to fragmentation analysis ingeneral and, more particularly, to a rock fragmentation analysis systemfor analyzing blasted rock.

BACKGROUND ART

[0002] Fragmentation analysis of blasted rock is an important processcontrol activity, particularly in underground mining, for optimizingproductivity and cost. Fragmentation analysis includes the estimation ofmean particle size and the size distribution related to percent passingin a sieve analysis. With the advancement of camera and imagingtechnology, the use of photographic based image analysis systems hasbecome a convenient and better alternative to traditional sieving ofrock blasts. As a result, mining industries have recently taken aninitiative to implement automated image analysis systems for rockfragmentation analysis.

[0003] An automated image analysis system has the capacity to monitorthe blasted material quality continuously as opposed to only samplingdata analysis as in the case of traditional sieving. However, automatedimage analysis processing requires the images to be taken undercontrolled lighting conditions to produce more consistent results.Further, commercially available fragmentation software packages are onlyable to produce fragmentation distribution curves from single digital,print photographs, 35-mm slides or videotapes. For each image, a scaleneeds to be selected and defined to create a net. Established algorithmsare then used on the net to generate a cumulative fragmentationdistribution curve. A major drawback of these available softwarepackages is that they can only analyze one image at a time.Determination of fragmentation, however, generally requires analysis ofmany images.

[0004] Accordingly, there is a need for a rock fragmentation systemcapable of processing multiple digital photographs of fragment material,e.g., rock piles, within a file directory, generating a fragmentationdistribution for each digital photograph, and a total fragmentationdistribution based on all the digital photographs.

SUMMARY OF THE INVENTION

[0005] There is provided a rock fragmentation analysis system foranalyzing blasted rock (or other fragmented particles) to assess qualityof a blast for efficient processing of subsequent operations in a mine,a quarry, etc. The system includes a hardware system and an imageprocessing system. The hardware system includes a camera and a lightingsystem. The lighting system illuminates an area of the mine, quarry,etc. where a load haul dump (LHD) vehicle passes through. Once the LHDvehicle passes through the illuminated area, the camera provides videosignals of scoop-top view images of the LHD vehicle to the imageprocessing system via known communication means, such as hard-wired andwireless. Each LHD rock scoop is tagged using a bar code to identify therock scoops as they travel through the camera's field of view.

[0006] The image processing system is preferably a computer or a serverwhich receives the video signals, captures the scoop-top view images,evaluates the images for subsequent fragmentation analysis, and performsthe rock fragmentation analysis. The image processing system performsthese functions using several software modules having a set ofinstructions which are executed by one or more processors of the imageprocessing system. Two such software modules are the FragmentationScanning (FragScan™) and the Fragmentation Analysis (FragAnalysis™)software modules.

[0007] The FragScan software module scans the video signals until itcaptures a valid image for analysis by the FragAnalysis software module.Once the FragScan triggers on the image, a raw image and other detailscorresponding to the captured image are buffered for subsequent analysisby the FragAnalysis software module. FragAnalysis is designed toretrieve saved raw images and perform a complete rock fragmentationanalysis of the image. The rock fragmentation analysis is designed toestimate the major diameter of each rock visible in the image.Preferably, the overall size distribution of the rocks in the image isoutput by the FragAnalysis software module as a text file, and thecorresponding input image and the binary blob image, i.e., the processedimage, are stored in a compressed format, such as in the jpeg format.

[0008] The rock fragmentation analysis system is designed to operateon-line, i.e., while the mine, quarry, etc. is fully functional.Preferably, the two or more processors provided within the imageprocessing system distribute the processing load of the image processingsystem.

BRIEF DESCRIPTION OF THE DRAWINGS

[0009]FIG. 1 is a schematic block diagram representation of anembodiment of a rock fragmentation analysis system of the invention.

[0010]FIG. 2 is a schematic plan view representation of a mountingarrangement for a camera and a lighting system of the rock fragmentationanalysis system of FIG. 1 for scanning a bucket of a load haul dump(LHD) vehicle.

[0011]FIG. 3 is a schematic elevation view representation of themounting arrangement for the camera and the lighting system of the rockfragmentation analysis system of FIG. 1.

[0012]FIG. 4A is a schematic representation of a sample tag forattaching to a rock scoop of the LHD vehicle.

[0013]FIGS. 4B and 4C illustrate the orientation of the tag according todifferent directional paths of the LHD vehicle.

[0014]FIG. 5 is an original image showing rock fragments as captured byan image processing system of the rock fragmentation analysis systemfrom a video feed.

[0015]FIG. 6 is an associated image of the original image shown by FIG.5 where the rock fragments have been segmented by the image processingsystem.

[0016]FIG. 7 is a chart showing the volume distribution curvescalculated from manually tracing the rock fragments of FIG. 5 accordingto the prior art and from analyzing the segmented rock fragmentsaccording to the invention.

[0017]FIG. 8 shows the main features to be extracted from a bucket imageto construct a region of interest (ROI) image.

PREFERRED EMBODIMENT OF THE INVENTION

[0018] Referring to FIG. 1, there is shown a schematic block diagramrepresentation of an embodiment of a rock fragmentation analysis systemof the invention. The invention is described herein in the context ofanalyzing rock scoops loaded on load haul dump (LHD) vehicles forremoving blasted rock from within a mine tunnel. It is contemplated thatthe system of the invention may also be used in analyzing scoops ofblasted rock obtained from other enclosed environments, such as atunnel, cave, building, etc., or overhead (i.e., external) surfaceenvironments, such as a rocky terrain.

[0019] The rock fragmentation system designated generally by referencenumeral 10 typically includes a hardware system 12 and an imageprocessing system 14. The hardware system 12 includes at least onecamera 16 and a lighting system 18 having a plurality of lightingfixtures 20 (see FIG. 2). The lighting fixtures 20 are preferably four500-watt quartz-halogen flood lights. The camera 16 is set to view thetop surface of the rock scoop. Preferably, the camera 16 is a CCD colorvideo camera equipped with a wide angle lens that yields a 4.25 meter(14 ft) field of view at a distance of 2.43 meters (8 ft).

[0020] The lighting system 18 illuminates an area of the mine, quarry,etc. where a LHD vehicle 22 (see FIG. 3) passes through. Once the LHDvehicle 22 passes through the illuminated area, the camera 16 providesvideo signals of scoop-top view images of blasted rock within a bucket24 (see FIG. 2) of the LHD vehicle 22 to the image processing system 14via known communication means, such as hard-wired and wireless. It ispreferable to set up the hardware system 12 at a location in the minewhere the LHD vehicle speed and dust conditions are minimum for acapturing good quality video images.

[0021] With reference to FIGS. 2 and 3, there are shown plan andelevational views, respectively, of a preferred mounting arrangement forthe camera 16 and the lighting fixtures 20 of the lighting system 18.The lighting fixtures 20 are located at the corners of a square 1.5meters (5 feet) on each side. The camera 16 is located in the center ofthe square. The viewing window of a camera enclosure 17 which enclosesthe camera 16 is in the same horizontal plane as the lighting fixtures20.

[0022] The distance between the top of the bucket 24 and the camera 16should be a minimum of 2.4 meters (8 feet) in the vertical direction.The camera 16 is mounted along the centerline of the drift. The sides ofthe square defined by the lighting fixtures 20 are parallel to the edgesof the bucket 24 as the bucket 24 travels beneath the camera 16. Thelong axis of the field of view of the camera 16 is perpendicular to thedirection of travel of the LHD vehicle 22. This is achieved by havingthe bottom of the camera 16 face the direction of approach of the LHDvehicle 22 when the LHD vehicle 22 is mounted on the mine back.

[0023] The image processing system 14 is preferably a computer or aserver having a central processing unit (CPU) which receives the videosignals from the hardware system 12 via a communication channel,captures the multiple scoop-top view images, evaluates the images forsubsequent fragmentation analysis, and performs the rock fragmentationanalysis for generating a fragmentation distribution for each image,and/or a total fragmentation distribution based on two or more, e.g.,all of the images, of the images of fragmented particles, i.e., muckpiles, produced with blast specific conditions. The image processingsystem 14 performs these and other functions using several softwaremodules having a set of instructions which are executed by one or moreprocessors, such as the CPU, of the image processing system 14. Two suchsoftware modules are the Fragmentation Scanning (FragScan) 26 and theFragmentation Analysis (FragAnalysis) 28 software modules.

[0024] The FragScan software module 26 is preferably activated by anoperator via a graphical user interface (GUI) for scanning the videosignals until one or more valid images for analysis are captured by theimage processing system 14. Once the FragScan software module 26triggers on the image, a raw image 30 and other details corresponding tothe captured image, such as an identifier value for identifying the rockscoop as described below with reference to FIG. 4A, are stored within animage database for subsequent analysis by the FragAnalysis softwaremodule 28. Portions of each raw image 30 may be edited to avoid takinginto account background and foreground features, e.g., sky and ground,that might be interpreted by the image processing system 14 as fines,i.e., indistinguishable particles.

[0025] The FragScan software module 26 is further able to automaticallydetect a white rectangular scale from the raw image 30 to provide alength scale for automatic scaling during image analysis as describedbelow. The length scale converts pixel data into length measurements.The FragScan software module 26 also allows one to use a user-definedfixed default value for scaling, rather than automatic scaling.

[0026] With reference to FIG. 4A, each LHD rock scoop is tagged using anidentification tag 50 representing a bar code having a unique value toenable the FragScan software module 26 to identify the rock scoops asthey travel via the LHD vehicles 22 through the camera's field of view.The tag 50 is also used by the FragScan software module 26 to determinethe orientation of the LHD vehicle 22, i.e., to determine which end ofthe LHD vehicle 22 is the bucket-end with respect to an ore pass or adump site. The information obtained from the tag 50 is encoded andstored within a file corresponding to the rock scoop image of the rockscoop for later identification and analysis by the FragAnalysis softwaremodule 28.

[0027] The location of the ore pass or the dump site relative to thecamera 16 is specified in setup or initiation files within the imageprocessing system 14. For example, if the dump site is above thecamera's field of view a dump site orientation value in the FragScansoftware module 26 is set to one, and if it is below the camera's fieldof view, the dump site orientation value is set to two (see Table 1).The system 10 needs to know the dump site orientation value in order todetermine if the rock scoop is on its way to or from the ore pass or thedump site. A LHD vehicle 22 approaching the ore pass or the dump site isassumed to have a full bucket of muck or rocks. Accordingly, theFragScan software module 26 is able to select an appropriate image ofthe vehicle's bucket 24 to send to the FragAnalysis software module 28.

[0028] As shown by the exemplary tag of FIG. 4A, the tag 50 attached toeach rock scoop includes a series of markers 52 that indicate variouspieces of information to the FragScan software module 26. End markers 52a and 52 j are red so they are quickly identified by image analysisalgorithms of the image processing system 14. All of the other markers52 b-i are either black or white to indicate a bit value of either zeroor one. The direction markers 52 b, 52 i are fixed, i.e., either blackor white, for all tags 50 so that the direction in which the tag 50 canbe read can be determined, in order to determine the orientation of therock scoop. As shown by FIGS. 4B and 4C, the system 10 assigns a valueof one or two for the rock scoop orientation value (see Table 1), basedon the orientation of the white direction marker. For example, FIGS. 4Band 4C illustrate the orientation of the white direction marker on theleft hand-side when facing the front of the LHD vehicle 22. ID markers52 c-h make up a binary number that is read with the least significantbit being the one adjacent to the start marker. In FIG. 4A, the tag 50is a six bit number with a value of 2⁰+2²+2⁵=37.

[0029] A “trip wire” or scanning software module of the FragScansoftware module 26 detects the entry and exit of an object, such as theLHD vehicle 22 and a maintenance worker, from the camera's field ofview. The “trip wire” software module takes two narrow bands of pixelsat the top and bottom of the camera's field of view, and calculates thestandard deviation of the intensity of the red channel pixels within thetwo narrow bands of pixels. The calculated standard deviation is thencompared to a standard deviation of an image that is known not to havean object therein, e.g., a blank image. It has been demonstrated that ifthe standard deviation is greater than the standard deviation of theimage that is known not to have an object therein, then an object hasentered the camera's field of view.

[0030] The object that entered the camera's field of view could be oneof the following:

[0031] 1. An LHD vehicle 22 in forward gear entering from the top of thecamera's field of view.

[0032] 2. An LHD vehicle 22 in forward gear entering from the bottom ofthe camera's field of view.

[0033] 3. An LHD vehicle 22 in reverse gear entering from the top of thecamera's field of view.

[0034] 4. An LHD vehicle 22 in reverse gear entering from the bottom ofthe camera's field of view.

[0035] 5. Other (such as a maintenance worker).

[0036] If the top and bottom regions of the camera's field of view aredesignated as regions or masks A and B, then the order in which theseregions are tripped indicates the direction of motion of the object; andif the object has an identification tag 50 on it, then one can determinethe object's orientation as well. Whenever an object enters the camera'sfield of view, the first “trip wire” that it triggers is denoted as trip1 and the second as trip 2. Therefore, the sequence of events is thefollowing for an object entering the camera's field of view: (1) trip 1is set; (2) trip 2 is set; (3) trip 1 is cleared; and (4) trip 2 iscleared.

[0037] An image is recorded by the camera 16 when trip 2 is set; theimage is designated as the “forward” image. This is the image that willbe passed to the FragAnalysis software module 28, if it is determinedthat the LHD vehicle 22 is moving forward, i.e., a path orientationvalue in the initiation file is assigned a value of one. An image isalso recorded when trip 1 clears; the image is designated as the“reverse” image. This is the image that will be passed to theFragAnalysis software module 28, if it is determined that the LHDvehicle 22 is in reverse, i.e., the directional path orientation valuein the initiation file is assigned a value of two (see Table 1). Ineither case, the unused image is discarded. TABLE 1 Dump site, rockscoop, and directional path of LHD vehicle orientation values fordetermining condition of the LHD vehicle and action to be taken by thesystem of the invention. Rock Dump Site Scoop Directional Orien- Orien-Path tation tation Orientation Condition Action 1 1 1 Approaching dumpsite Process in forward gear--bucket First should be full. image 1 1 2Leaving dump site in Do reverse gear--bucket nothing should be empty. 12 1 Approaching dump site Process in reverse gear--bucket Second shouldbe full. Image 1 2 2 Leaving dump site in Do forward gear--bucketnothing should be empty. 2 1 1 Leaving dump site in Do forwardgear--bucket nothing should be empty. 2 1 2 Approaching dump siteProcess should be full. Second Image 2 2 1 Leaving dump site in Doreverse gear--bucket nothing should be empty. 2 2 2 Approaching dumpsite Process in forward gear--bucket First should be full. Image

[0038] Between the time trip 1 is set and trip 2 is cleared, theFragScan software module 26 looks for an identification tag 50 in theimage. If a tag 50 is not found within a predetermined time-out period,the object that has entered the camera's field of view is assumed to besomething other than a LHD vehicle 22.

[0039] If a tag 50 is found within the predetermined time-out period byemphasizing features on the video image that match the red markers ofthe tag 50, e.g., markers 52 a and 52 j of the tag 50 shown by FIG. 4A,by a Tag Pre-process software module of the FragScan software module 26,a Tag Position software module of the FragScan software module 26 thendetermines whether the video image contains a tag 50, and if so, thelocations of its red markers. It is contemplated that only the portionof the video image where the tag 50 should be located is examined tospeed up image processing of the video image.

[0040] The features on the video image that match the red markets areemphasized by the Pre-process software module by extracting the red andgreen channels from the video image; creating an error image bysubtracting the green channel from the red channel, such that the brightareas of the error image are those with the strongest red component;calculating a histogram of the error image (which is grayscale)containing the number of pixels at each intensity level; and determiningwhether the number of pixels at the intensity level corresponding to theintensity level of pixels of the red markers is approximately equal to apredetermined number of pixels, i.e., the actual number of pixels whichmake up the red markers.

[0041] As mentioned above, the Tag Position software module of theFragScan software module 26 then determines if the video image containsa tag 50, and if so, the location of its red markers by calculating theareas, convex perimeters, and compactness of all the blobs in theprocessed video image (FIG. 6 illustrates a processed video image) usingblob analysis routines as known in the art; excluding any blobs thatfall outside predetermined limits as set in an initiation file;calculating the x and y coordinates of all remaining blobs; finding thepair of blobs whose separation distance is closest to that of the endmarkers; copying the x-y coordinates of the two blobs, i.e., x1, y1coordinates of the first blob, and x2, y2 coordinates of the secondblob, and outputting a bit having a value of one, i.e., the video imagecontains a tag 50, if a separation error of the two blobs is less thanthe maximum value specified in the initiation file; and otherwise,returning a bit having a value of zero, i.e., the video image does notcontain a tag 50.

[0042] If a tag 50 is determined to be contained by the video image, aTag Value software module of the FragScan software module 26 determinesthe value of the tag 50 by calculating the equation of a line passingthrough x1, y1 and x2, y2; dividing the line up into segments equal tothe number of bits in the tag 50 as indicated in the initiation file;determining the mean value of the pixels at the end of each linesegment, where the number of pixels used to calculate the mean value isdetermined by a marker radius parameter which indicates the radius ordistance of each marker and is stored in the initiation file;determining the mean value and the distance or range of the first andlast bits in the tag 50 which are either black and white, where if thedistance is less than a set value, the image is assumed not to be a tagand an error is returned; and if the distance is greater than the setvalue, determining the tag orientation and value.

[0043] The FragAnalysis software module 28 is designed to retrieve savedraw images other information obtained by the FragScan software module 26and perform a complete rock fragmentation analysis of the image uponopening the saved raw images via the GUI, and output results 32 (seeFIG. 1). It is contemplated that the FragAnalysis software module 28 maybe programmed to execute and terminate automatically without operatorintervention.

[0044] The rock fragmentation analysis performed by the FragAnalysissoftware module 28 is designed to estimate the major diameter of eachrock visible in the image. Preferably, the rock measurements, theoverall size distribution of the rocks in the image, a name of theimage, the time of scan, the LHD number, and camera number are output bythe FragAnalysis software module 28 as one or more text files, and thecorresponding input image as shown by FIG. 5 and designated generally byreference numeral 55, and the blob image, i.e., the processed image asshown by FIG. 6 and designated generally by reference numeral 60, aresaved in a compressed format, such as in the jpeg format.

[0045] Once the analysis is completed for a set of input images, i.e., abucket image as shown by FIG. 5 and its background image, the inputimages are transferred to an output directory. The analysis thenrepeats, preferably automatically, for each set of input images found inan input directory.

[0046] In case of a fatal error, the analysis terminates and the time ofoccurrence of the fatal error is noted in a log file. In case of afunctional error, the FragAnalysis software module 28 returns withoutfurther processing the set of input images. The two input images and theerror file are then transferred to the output directory and analysiscontinues for a subsequent set of input images.

[0047] Once the FragAnalysis software module 28 is initiated, itautomatically allocates all the memory buffers necessary for imageprocessing and reads all pre-set or predetermined variables in theinitiation file. The operator can change the pre-set variables using theGUI and save them in the initiation file for future use by the system10. The system 10 deallocates all the buffers in case of a fatal errorwhen executing the FragAnalysis software module 28.

[0048] Once the operator initiates rock fragmentation analysis, e.g., byclicking on a start soft button from a process menu in the GUI, thefollowing functions are executed by an exemplary FragAnalysis softwaremodule 28.

[0049] 1. All of the images having extensions *.tif, *.bmp and * jpg areretrieved from the input directory and stored in a file array. Thefollowing image processing functions are performed for each imageretrieved from the input directory.

[0050] 2. Import the color image and split into three RGB (Red, Greenand Blue) channels. Produce the intensity (gray scale) image.

[0051] 3. Select a region of interest (ROI) window from the image byperforming an ROI_Detection( ) function as described in detail below.

[0052] 4. If auto-scaling option is enabled, then perform AutoScale( )function as described in detail below to generate the conversionparameter length to pixel ratio (LPR). If auto-scaling is disabled, thenread the default LPR value from the initiation file.

[0053] 5. Perform a segmentation process for the ROI area of the imageto generate a segmented gray scale (see FIG. 6) for fragmentationanalysis. The processing is performed using two functions as follows:

[0054] BlobSeparation( ) function as described in detail below separatesall brightly visible blobs in the image and stores the segmented blobs,such as blobs 62 and 64 in FIG. 6, in a separate image buffer.

[0055] EdgeSeparation( ) function as described in detail belowdetermines the rock edges (boundaries) of rocks found in thenon-segmented area during the BlobSeparation process. The blob imageproduced after BlobSeparation is then combined with the edge imageproduced after EdgeSeparation to produce the final Blob Image of therock image. The Blob Image is save in a Blob Image file and includesthree gray levels. Black represents the background, white represents thesegmented blobs, and gray represents the fines (see FIG. 6).

[0056] 6. Perform AnalysisResults( ) function as described in detailbelow to produce the major and minor diameters of each blob and thecumulative volume distribution of the blobs found in the Blob Image fileto produce the fragmentation results which are written into the selectedoutput directory.

[0057] 7. If the process is stopped during processing, terminate theanalysis execution, deallocate all buffers, and return to an idlecondition. Otherwise, repeat steps 2 through 6 for the next image foundin the input directory.

[0058] The FragAnalysis software module 28 further performs theBlobValidity( ) function to test whether the bucket image that has beentaken for analysis from the input directory is a correct picture, i.e.,test the validity of the captured bucket image. The inputs of theBlobValidity( ) function are the bucket intensity and green images, andthe output is whether the bucket image is valid.

[0059] The following functions are performed by an exemplaryBlobValidity( ) function:

[0060] 1. Generate and edge image corresponding to the input bucketintensity image.

[0061] 2. Calculate the average edge intensity value of the edge image.

[0062] 3. If the average edge intensity value is less than the pre-setminimum edge value, return an error code for low contrast, i.e., invalidbucket image.

[0063] 4. Extract green image of the RGB color image.

[0064] 5. Using stochastic edge filter, generate a vertical edge imageof the green channel.

[0065] 6. Thin the edges to skeleton

[0066] 7. Remove all short lines.

[0067] 8. Mask top and bottom 60 rows of the edge image.

[0068] 9. Find the longest 20 vertical lines after determining thevertical lines.

[0069] 10. Count the number of pairs of parallel lines.

[0070] 11. If the image contains two or more pairs of parallel lines,the function returns an error code indicating a non-bucket image.

[0071] 12. If the image contains either one or no pairs of parallellines, the image is returned to be a valid bucket image.

[0072] As indicated above, the FragAnalysis software module 28 performsthe ROI_Detection( ) function which receives as inputs the bucketintensity image and the background intensity image and outputs the ROIimage. The following functions are performed by an exemplaryROI_Detection( ) function:

[0073] 1. First check whether the gray level bucket intensity image andgray level background intensity image are non-empty.

[0074] 2. Subtract the gray level background image from the gray levelbucket image and obtain a subtracted image as shown by FIG. 8.

[0075] 3. Obtain an edge image corresponding to the subtracted image.

[0076] 4. Check the mean edge intensity. If the mean edge intensity isbelow a predetermined value, return an error code for invalid bucketimage. Otherwise, proceed to the next step.

[0077] 5. Find mean (Mean1) and standard deviation (Sigma2) of the leftportion (designated left mask in FIG. 8) of the subtracted image (FIG.8).

[0078] 6. Find mean (Mean2) and standard deviation (Sigma2) of the rightportion (designated right mask in FIG. 8) of the subtracted image.

[0079] 7. Compute Mean=minimum(Mean1, Mean2) and Sigma=maximum(Sigma 1,Sigma2).

[0080] Search Left and Right Edges

[0081] 8. Define a range for binarizing the subtracted image (FIG. 8) asthreshold_lower_limit=maximum(10, Mean—Sigma) and threshold_upper_limit=Mean+20.

[0082] Begin a for-loop:

[0083] 9. Begin a for-loop for varying the binarizing threshold fromthreshold_lower_limit to threshold_upper_limit by steps of 10.

[0084] 9.1 Binarize the subtracted image above the defined threshold andobtain a binary image.

[0085] 9.2 Fill holes that exist in the blobs of the binary image.

[0086] 9.3 Isolate all blobs having a width greater than a predeterminednumber of pixels, e.g., 100 pixels.

[0087] 9.4 Isolate all blobs having Feret_Elongation greater than apredetermined value, e.g., five.

[0088] 9.5 Delete all other narrow blobs.

[0089] 9.6 Using a Laplacian filter, obtain the edge image.

[0090] 9.7 Perform Hough transform for the left masked portion of theedge image and determine the best straight line. The Hough transformfunction returns the maximum pixel count, slope and intercept for thebest line. Define CountLeft=pixel count.

[0091] 9.8 Similarly perform Hough transform for the right maskedportion of the edge image and determine the best straight line. DefineCountRight=pixel count.

[0092] 9.9 Compute top width and bottom width (see FIG. 8) correspondingto the above constructed two lines.

[0093] 9.10 Reset a Flag=1.

[0094] 9.11 Compare the two lines against Max_Width (default 470),Min_Width (default 300), Max_Total (default 800), Min_Total (default695) and CountTh (default 100).

[0095] If (Top Width>Max_Width OR Top Width<Min_Width) OR

[0096] If (Bottom Width>Max_Width OR Bottom Width<Min_Width) OR

[0097] If (Top Width+Bottom Width>Max_Total OR Top Width+BottomWidth<Min_Total) OR

[0098] If (CountLeft<CountTh OR CountRight<CountTh), then Flag=0.

[0099] 9.13 If the test is successful (and Flag=1), return thecoordinates of the two lines for ROI Image and go to step 17.

[0100] 9.14 If the test is unsuccessful and Flag=0, then check thefollowing conditions for an invalid image.

[0101] 9.15 Check the image validity.

[0102] If (Flag=0) AND if (CountLeft>CountTh And CountRight>CountTh),break the loop and return the error code for an invalid bucket image andterminate the ROI_Detection. If not continue the for-loop.

[0103] 9.16 Based on the maximum CountLeft and CountRight, retain thebest Left and Right lines for sub-level testing.

[0104] 9.17 If (Flag=0), then increment the Binarizing threshold by 10units and continue the for-loop.

[0105] End of for-loop.

[0106] 10. If Flag=0, then use sub-level testing based on the best leftand right lines detected in the above for-loop.

[0107] 11. Recompute Top Width and Bottom Width based on the bestdetected left and right lines.

[0108] 12. Reset Flag=1.

[0109] 13. If (Top Width>Max_Width OR Top Width<Min_Width) OR

[0110] If (Bottom Width>Max—Width OR Bottom Width<Min_Width) OR

[0111] If (Top Width+Bottom Width>Max_Total OR Top Width+Bottom

[0112] Width<Min_Total), then Flag=0.

[0113] 14. If the test is successful, return the two lines for ROI Imageand go to step 17. If unsuccessful, proceed to the second level of linedetection.

[0114] 15. Instead of using subtracted image in step 5, use the bucketintensity image and repeat steps 5 through 14. If valid lines aredetected and Flag=1, go to step 17. If unsuccessful, proceed to the nextstep.

[0115] 16. If Flag=0, then select the best line detected in step 9 andestimate the second line keeping a distance equal to the average widthof Max_Width and Min_Width and go to step 17.

[0116] 17. Begin construction of ROI image by first making a blank whiteimage. Then darken the areas outside of the two detected lines. Obtainaccurate left and right borders with over flown rock boundaries

[0117] 10. Binarize the subtracted image above a threshold equal to(Mean minus 10).

[0118] 11. Extract all the blobs touching the two detected lines fromthe binarized image.

[0119] 12. Extract the overflown blobs touching the two detected linesin the above binary image.

[0120] 13. If the two lines have been estimated from step 16, thenoverlay all overflown blobs to the ROI image. Otherwise, delete all theblobs having compactness greater than a predetermined value, e.g., 2.5,and roughness greater than a predetermined value, e.g., 1.5.

[0121] 14. Overlay (Binary OR) the selected overflown blobs to ROIimage.

[0122] Construction of the Bottom Border

[0123] 10. Select a rectangular window at the bottom portion of thesubtracted image, as shown in FIG. 8.

[0124] 11. Compute mean (Mean) and standard deviation (Sigma) of thepixel intensity within the selected window of the subtracted image.

[0125] 12. Binarize the subtracted image above a threshold given bymaximum (Mean minus Sigma+5, 10).

[0126] 13. Darken the left and right areas of the binarized image fromthe detected left and right lines, respectively.

[0127] 14. Further darken the top portion, i.e., a predetermined numberof rows, e.g., 300 rows, in the image.

[0128] 15. Invert the image to obtain a single blob that corresponds tothe lower portion of the bucket image.

[0129] 16. Remove any smaller blobs remained after inverting the imageand keep the blob having Feret_X width greater than (bottom width minus50).

[0130] 17. Obtain an edge image to represent the bottom border.

[0131] 18. Perform Hough transform on the above edge image twice toobtain Left V and Right V edge lines as shown in FIG. 8.

[0132] 19. Fill all the holes above the two detected V lines.

[0133] 20. Draw the two V lines on the existing ROI_Image and darken thearea below the V lines.

[0134] 21. Draw two V lines on the image and obtain all the blobsover-hanging from the two-bottom V edges.

[0135] 22. If the over-hanging blobs have compactness less than apredetermined value, e.g., three, and roughness below a predeterminedvalue, e.g., 1.2, overlay on the constructed ROI Image.

[0136] Construction of the Top Line

[0137] 10. Obtain the coordinates of the intersecting points A, B and Cas shown in FIG. 8.

[0138] 11. Obtain the horizontal edge image corresponding to theintensity bucket image.

[0139] 12. Select a window from the top area of the edge image.

[0140] 13. Perform the Hough transform to obtain the top line.

[0141] 14. Draw the obtained top line on the ROI_Image and darken thearea above the top line.

[0142] 15. Calculate distance between B and C and assign

[0143] BC=Bucket_Front_Width.

[0144] 16. Calculate width and height of the ROI_Image and assign to

[0145] Bucket_Width=Feret_X and Bucket_Length=Feret_Y.

[0146] 17. If Feret_Y<Min Width, then return the error code for aninvalid image.

[0147] 18. Otherwise return the ROI_Image for subsequent imageprocessing.

[0148] As indicated above, the FragAnalysis software module 28 performsthe BlobSeparation( ) function. Due to speckles and other rough texturesof rock surfaces, an edge detection algorithm tends to produce faultedges which result in an disintegration of the rock surfaces in the blobimage. As edge detection is based on neighborhood pixel intensitydifferences, the available algorithms are sensitive to high frequencynoise and require image preprocessing for noise removal. Thedisintegration due to noise and sharp internal edges usually results inan underestimate of the rock sizes.

[0149] Alternatively, the gray image can be binarized to isolatebrightly shown rock surfaces. Binarizing above a given threshold limitwill automatically remove the effects of noise that are visible in thebright regions of the image. Binarizing has the disadvantage ofisolating low intensity rock surfaces.

[0150] In most cases, the larger rocks appear brighter than small rocksand therefore the binarizing principle can be effectively used toisolate bigger blobs in the image. As binarizing is based on anintensity threshold, the binarizing method is unable to detect the darkor less bright rocks that are closely located with brightly visiblerocks. Also, very small rocks that are clustered together are unable toseparate from this function. Therefore, the BlobSeparation function,which has as inputs the gray scale bucket intensity image and theROI_Image produced by the RIO_Detection function( ) and outputs aBigBlob_Image (i.e., a binary image), is designed to produce largerblobs and also to isolate brightly visible rocks in the image. Thefollowing functions are performed by an exemplary BlobSeparation( )function:

[0151] 1. Initialize size limits for blobs based on ROI dimensions.

[0152] 2. Darken the outside area of the ROI in the bucket intensityimage.

[0153] 3. Calculate mean (Mean) and standard deviation (Sigma) of thebucket area.

[0154] 4. Create Empty images for creating blob images and call themBlob_Image1, Blob_Image2 and Blob_Iimage3.

[0155] Progressive Delineation of Blobs

[0156] Begin a for-loop

[0157] 5. Begin a for- loop by varying the threshold from Mean minusSigma minus 15 to Mean+Sigma+15 in steps of 5.

[0158] 5.1 Obtain a binary image of the bucket intensity image using thethreshold step.

[0159] 5.2 Mask-out the area outside the ROI.

[0160] 5.3 Fill the dark patches having a size smaller than shadowsize1(default is 60). Then, darken an area corresponding to the shadow areain the bucket intensity image and call it Binarized_Image1.

[0161] 5.4 Fill the dark patches having a feret diameter smaller thanshadowsize2 (default is 20). Then, darken an area corresponding to theshadow area in the bucket intensity image and call it Binarized_Image2.

[0162] 5.5 Create three different watershed lines for three cases asfollows:

[0163] Case a: Binarized_Image1 and set the minimum variation of thewatershed to 2. Overlay the watershed lines on Binarized_Image1 and callit Blob1.

[0164] Case b: Use Binarized_Image1 and set the minimum variation of thewatershed to 1. Overlay the watershed lines and Binarized_Image1 andcall it Blob2.

[0165] Case c: Use Binarized_Image2 and set the minimum variation of thewatershed to 1. Overlay the watershed lines on Binarized_Image2 and callit Blob3.

[0166] 5.6 For each case in step 5.4 perform the following:

[0167] 1. Keep the blobs satisfying all the conditions given below anddelete the blobs where one or more of the conditions fail.

[0168] Compactness<Compactness_threshold (Default value is 2)

[0169] Roughness<Roughness_threshold (Default is 1.2)

[0170] Fraction of watershed lines on the perimeter<Fraction_threshold

[0171] (Defaults: 0.45 for case a, 0.3 for case b, and 0.2 for case c).

[0172] 2. Isolate blobs touching front and side edges of the bucket(i.e., borders in the ROI Image) for removing any bucket edge effects.Delete the blobs having edges falling 70% outside their X and Ydimensions.

[0173]5.7 Perform the following operations:

[0174] For case a, Blob1 OR Blob_Image1|Blob_Image1,

[0175] for case b, Blob2 OR Blob_Image2|Blob_Image2, and

[0176] for case c, Blob3 OR Blob_Image3|Blob Image 3.

[0177] 5.8 Increment Binarizing threshold and repeat step 5.

[0178] End of for-loop.

[0179] 1. Clean unwanted lines from all three blob images in theprevious step.

[0180] 2. Remove small blobs from all three Blob images (forBlob_Image1, the major diameter threshold limit is 20 and for other twoblob images, the threshold limit is 50).

[0181] Making the Combined Big Blob Image from Three Blob Images

[0182] 1. Consider each blob in Blob_Image3 and overlay on Blob_Image2,only if the overlap area of the blob in Blob_Image3 on separated blobsin Blob_Image2 is less than 85% of its area.

[0183] 2. Reconstruct edges of the overlaid blobs.

[0184] 3. Select all the blobs in the combined blob imageand overlaythem in Blob_Image1.

[0185] 4. Reconstruct all edges of the overlaid blobs. Name the finalblob image and BigBlob_Image.

[0186] Removal of Bucket Edge Effects

[0187] 1. Consider BigBlob_Image and extract all the blobs touching topand bottom edge of the ROI_Image.

[0188] 2. Leave all the blobs extending beyond the front edge of thebucket.

[0189] 3. Delete blobs that are inline with bucket edges and updateBigBlob_Image.

[0190] 4. Again consider BigBlob_Image and extract blobs touching theside edges and top left and right corners of the ROI_Image.

[0191] 5. Leave all the blobs that are extending beyond the side edgesof the bucket.

[0192] 6. Delete blobs that are inline with the bucket side edges.

[0193] As indicated above, the FragAnalysis software module 28 performsthe EdgeSeparation( ) function. This function has two main parts. In thefirst part, it performs an edge detection algorithm to find all edges inthe bucket image. With further image enhancements, a blob image isobtained. The unsegmented area is assumed to be fines in the bucketcontent. In the second part, the blob image obtained from theBlobSeparation( ) function is combined to produce the final blob imageof the bucket content. The inputs of the EdgeSeparation function are theROI_Image, the filtered RGB images of the bucket color image, and theBigBlob_Image and the output is a three gray level Blob_Image. Thefollowing functions are performed by an exemplary EdgeSeparation( )function:

[0194] 1. Define two edge thresholding values as threshold_low andthreshold_high.

[0195] 2. Set the edge threshold limits to a first set of values(defaults, threshold_low=20 and threshold_high=25).

[0196] 3. Using the three RGB bucket images and the first set of edgethresholding values, perform an Edge_RGB( ) function as described indetail below. This function returns an edge image corresponding to thebucket image.

[0197] 4. Using the ROI_Image, select the edges in the ROI region andcall Edge_Image1.

[0198] 5. Delete all open ended edge lines using a LineBlanking( )function and save to a different image buffer.

[0199] 6. Include blobs having compactness greater than a thresholdvalue (default 2.5).

[0200] 7. Copy Edge_Image1 to a temporary buffer and darken all theincluded blobs.

[0201] 8. Extend the open-ended lines in the temporary buffer by 3pixels.

[0202] 9. Copy the included blobs to the temporary buffer and rename itas Edge_Image1.

[0203] 10. Check occurrence of any unacceptable larger blobs.

[0204] 11. Using blob-by-blob analysis, remove all the edges other thanthe main border of the blob.

[0205] 12. Recalculate compactness and copy unsegmented area to atemporary buffer.

[0206] 13. Perform watershed MIL operation on the unsegmented area inthe temporary buffer.

[0207] 14. Select watershed lines only if they occupy less than 30% ofthe perimeter of a given blob having a compactness less than thethreshold compactness value.

[0208] 15. Recalculate the compactness and copy segmented blobs back toEdge_Image1.

[0209] 16. Extract blobs touching the edges of the ROI_Image.

[0210] 17. Delete blobs that are aligned with bucket edges.

[0211] 18. Copy the unsegmented area to Edge_Image1 and assign a grayscale 200.

[0212] 19. Rename the image Blob1.

[0213] 20. Assign the second edge threshold values (defaults,threshold_low=25 and threshold_high=30) and repeat steps 3 through 17and rename the final image as Blob2.

[0214] Produce Final Edge-Based Image

[0215] 1. Select all valid blobs from Blob2 and copy to a temporarybuffer1 .

[0216] 2. Binarize Blob2 exactly at gray level 200 to obtain theunsegmented area image.

[0217] 3. Obtain all valid blobs from Blob1 and copy to a temporarybuffer2.

[0218] 4. Obtain all blobs in temporary buffer2 that fall into theunsegmented area of Blob2.

[0219] 5. Copy those blobs to temporary buffer1.

[0220] 6. Again assign gray level 200 for the unsegmented area and copyto Edge_Image.

[0221] Combine BigBlob Image and Edge Image

[0222] 1. Select all valid blobs from Edge_Image and copy to a temporarybuffer.

[0223]2. Select blobs that have a major diameter greater than 80 fromthe Edge_Image.

[0224] 3. Overlay the selected big blobs on BigBlob_Image only if agiven selected blob does not overlap more than 85% of its area on thesegmented blobs in the BigBlob_Image.

[0225] 4. Reconstruct edges of the overlaid blobs and copy all blobs tothe final Blob_Image.

[0226] 5. Select an unsegmented region of the Blob_image from theEdge_Image.

[0227] 6. Overlay the selected area back on Blob_Image.

[0228] The Edge_RGB( ) function performed by the FragAnalysis softwaremodule 28 uses three edge images produced from red, green and bluechannels and returns an edge image for the EdgeSeparation( ) function.The following functions are performed by the Edge_RGB( ) function:

[0229] 1. Using the filtered bucket red image, perform an functionEdgeDetect( ) function as described in detail below. The output edgeimage is called EdgeR_Image.

[0230] 2. Similarly using the bucket green and blue images, perform thefunction EdgeDetect( ) to obtain EdgeG_Image and EdgeB_Image.

[0231] 3. Using an OR operation combine all three edge images and obtaina single image call Edge_Image.

[0232] 4. Perform the thinning operation.

[0233] 5. Obtain the shadow area from the bucket intensity image andoverlay on the Edge_Image.

[0234] The Edge_Detect( ) function performed by the FragAnalysissoftware module 28 uses hysteresis thresholding. The function takes afiltered gray scale image and returns a binary edge image. The followingfunctions are performed by the Edge_Detect( ) function:

[0235] 1. Create four edge convolution masks to produce edges in fourdirections (zero, 45, 90 and 135 degrees).

[0236] 2. Convolve each mask with a gray input image and produce fouredge matrices, namely, Edge0, Edge45, Edge90 and Edge 135.

[0237] 3. Create four empty image buffers for registering edges.

[0238] Perform Hysteresis Thresholding

[0239] Repeat the following steps 4 through 7 for each Edge matrixproduced in step 3.

[0240] 4. Binarize the edges having an intensity greater thanthreshold_high and copy them to four allocated empty buffers.

[0241] 5. Delete all the edges having an intensity lower than thethreshold_low from the edge matrix.

[0242] 6. If an edge's pixel values lie between threshold_low andthreshold_high, then check the neighborhood pixels connected in the edgedirection. If the neighborhood pixels have any edges greater thanthreshold_high, binarize and copy to the corresponding edge imagebuffer.

[0243] Directional Thinning

[0244] 7. Select the highest edge intensity perpendicular to theselected direction and delete all other pixels until the thickness ofthe edge becomes a single pixel wide.

[0245] 8. Copy all the edges to a single image and return as the outputbinary edge image.

[0246] The AnalysisResults( ) function performed by the FragAnalysissoftware module 28 is the final function performed to produce themeasurements of the rock sizes and their volume distribution. Thefunction takes the Blob_Image produced from the EdgeSeparation( )function. The white regions (pixel value 255) represents the segmentedrock surfaces and gray scale (pixel value 200) represents the fines inthe bucket 24. Dark pixels (pixel value 0) represent the background ordark shadows in the bucket image. All the sizes are preferably measuredin centimeters.

[0247] The inputs to the AnalysisResults( ) function are the Blob_Image,the Bucket_Front_Width_returned from the ROI_Detection( ) function, andthe actual bucket width obtained from the initiation file. The outputsare the raw measurements of rocks in (cm), volume distribution (cubiccm) and percentage of passing versus major diameter of the rocks (e.g.,as shown by FIG. 7) and the binary blob image.

[0248] The AnalysisResults( ) function uses the following assumptions:

[0249] a. For scaling assume the distance between bottom left and bottomright corners of the ROI_Image is equal to the actual width of thebucket 24.

[0250] b. For volume measurements assume the 3-D shape of a blob asellipsoidal having the major and minor diameters respectively equal tothe maximum and minimum feret diameters of the segmented blob.

[0251] c. For fines, assume the unsegmented area has a depth equal tothe minimum feret diameter obtained from the blob analysis. If theminimum feret diameter is greater than the maximum depth (default 90cm), then take the maximum depth.

[0252] d. Assume the volume of the total fines belong to the lowest sizerange in the volume distribution.

[0253] The following functions are performed by the AnalysisResults( )function:

[0254] 1. Calculate the LPR (length to pixel ratio) in cm/pixel.LPR=Bucket actual width/Bucket_Front_Width of the ROI_Image.

[0255] 2. Take all the valid blobs (gray scale 255) from the Blob_Imageand copy to a temporary buffer.

[0256] 3. Perform blob calculations and produce feature arrays formaximum feret diameter, and minimum feret diameter.

[0257] 4. Convert the diameters to cm using the LPR and assign them todifferent user arrays.

[0258] 5. Assuming an ellipsoidal shape, produce an array for volume(volume=4.1888×major_diameter×minor_diameter²).

[0259] 6. Sort the blob sizes according to the major diameter and thenwrite the major diameter and its corresponding minor diameter and volumeto a text file.

[0260] 7. Using a suitable step size (default is 5 cm) create severalbins based on major diameter and assign them to a new user array.

[0261] 8. Add all the numerical values of volumes in a given bin andthen write to a volume distribution array.

[0262] 9. Binarize the Blob_Image at the intensity equal to 200 forgenerating an image having fines.

[0263] 10. Perform blob calculation on the fine image and producefeatures, minimum feret diameter and pixel area.

[0264] 11. Using the LPR, convert above features to real units.

[0265] 12. For each blob take the depth=minimum (90, minimum feretdiameter in cm).

[0266] 13. Calculate the volume of each blob by takingvolume=area×depth.

[0267] 14. Sum all the area values in the array and add them to thelowest bin in the volume distribution.

[0268] 15. Based on the grand total of the volume distribution, producethe percentage volume distribution.

[0269] 16. Write major diameter, volume distribution and percentagevolume to a text file.

[0270] The FragAnalysis software module 28 further performs aBackground_Validate_Image( ) function to check a received image from theFragScan software module 26 to determine if the received image issuitable for transformation into a background image. TheBackground_Validate_Image( ) function returns a boolean true variable ifthe image is suitable for a background image and a boolean falsevariable if the image is not suitable for a background image.

[0271] The Background_Validate_Image( ) function preferably receives a640×480 RGB color image of a candidate image for a background image. TheBackground_Validate_Image( ) function converts the RGB image into HLSand then extracts out the hue channel. The sigma in the hue channel iscomputed for each of 16 horizontal bars (eight in the top ⅓ of the imageand another eight in the bottom ⅓ of the image). The function thenperforms several checks on this data and determines if the image issuitable for a background image or not. Images which contain pieces ofLHD or other equipment with a yellow color produce a reject condition.

[0272] To convert the RGB input image to a HLS image and extract out thehue channel the following functions are performed by an exemplaryBackground_Validate_Image( ) function:

[0273] 1. Clear the mask image to all black.

[0274] 2. Create white (solid, filled) rectangles on mask image whichare full width (480 pixels) and 19 pixels in height and 1 pixel verticalseparation between them. Create eight in the top ⅓ of the image startingfrom the y-coordinate position=8 and eight in the bottom ⅓ of the imagestarting at y-coordinate position=320. (The middle ⅓ of the image isignored.)

[0275] 3. Using the binary mask image and the hue channel, perform ablob analysis and compute the sigma for each rectangle. This shouldproduce 16 results. (If this data is plotted on a graph, the idealbackground image should produce a bell shaped curve. Any deviation fromthis curve is an indicator of an object in the image.)

[0276] 4. Compute the average value for the entire data set.

[0277] 5. Compute the average value of this data for the left, centerand right portions of this graph. The left value is the average of thefirst four points, the center value is the average of the middle fourpoints, and the right value is the average of the last four points.

[0278] 6. Normalize the left, center and right averages via the centervalue.

[0279] 7. Calculate the slope between the left and right average points.Slope=(avg_right minus avg_left)/12.

[0280] 8. If the absolute value of the normalized left or right valuesexceeds the threshold (normally set to 1.1), then return false (not asuitable background image).

[0281] 9. If the absolute value of the slope is greater than thethreshold (normally 0.01) then return false (not a suitable backgroundimage).

[0282] 10. If the average hue (computed in step 5) is greater than thethreshold (normally set to 70), then return false (not a suitablebackground image).

[0283] 11. If we reach this point, return true (a suitable backgroundimage).

[0284] The AutoScale( ) function is performed by the FragAnalysissoftware module 28 to locate two parallel side edges of a rectangularwhite scale positioned in the camera's image view. The pixel distancemeasured between the two parallel edges is used to obtain the conversionparameter LPR in cm/pixels. Accuracy up to a pixel is obtained whentracing the scale's edges. The straight scale edges are obtained byusing the Hough transformation method. Hough transformation can be usedto determine the best straight line passing through maximum number ofnon-zero pixels in a binary image.

[0285] Preferably the AutoScale( ) function is set to repeat a maximumof three times until a valid scale is found. During each cycle, thefunction searches for a valid scale. The function returns apredetermined value, e.g., 99999, when the AutoScale fails to find avalid scale.

[0286] An exemplary AutoScale( ) function performs the followingfunctions:

[0287] AutoScale Preprocessing

[0288] 1. Extract the saturation image channel from the HLS color inputimage. Compute the mean saturation intensity and its standard deviation.

[0289] 2. Compute the Binarizing Threshold as follows: Mean+Standarddeviation+threshold adjustment.

[0290] 3. Using the threshold obtained binary saturation image, performa blob analysis and remove the following blobs: remove all blobs havingsmaller diameters (e.g., less than 10 pixel); remove blobs if the height(ferret y diameter) or width (ferret×diameter) is greater than themaximum pixel limit; remove compacted blobs (e.g., below compactness 2);remove blobs having larger area (e.g., area greater than 2000); removeall blobs if they are connected to the ROI boundaries.

[0291] 4. Store the cleaned image in a binary image buffer.

[0292] AutoScaleVerticalEdges

[0293] 1. Find vertical edges of the cleaned binary image.

[0294] 2. Delete edges having greater width than height.

[0295] 3. Store the vertical edge image in an image buffer.

[0296] 4. If the resultant edge image is empty and has no edges, thenreturn a fail value, e.g., 99999.

[0297] AutoScaleHorizontalEdges

[0298] 1. Find horizontal edges of the cleaned binary image.

[0299] 2. Delete edges having greater height than width.

[0300] 3. Store the horizontal edge image in an image buffer.

[0301] 4. If the resultant edge image is empty and has no edges, thenreturn a fail value, e.g., 99999.

[0302] AutoScaleVerticalTwoLines

[0303] 1. Using Hough-transform determine the best fitting two verticallines in the vertical edge image.

[0304] 2. For each line, select the longest edge in the vertical edgeimage. Therefore, the final vertical edge image will have only twovertical edge segments corresponding to each vertical line and areexpected to represent the two vertical sides of the scale.

[0305] 3. Determine the centers of the two vertical edges.

[0306] 4. Based on the maximum pixel limit determine, a bounding boxisolating the two vertical edges.

[0307] 5. Select all horizontal edges falling within the selectedbounding box.

[0308] 6. Perform the following test:

[0309] 6.1 The horizontal distance between the two centers of the twovertical edges is within a predetermined range of distance.

[0310] 6.2 The vertical distance between the two centers of the twovertical edges is within a predetermined tolerance.

[0311] 6.3 At least one horizontal edge should exist within the boundingbox.

[0312] 7. If the test is true then assign Boolean variablesfind_horizontal_scale “true” and find_vertical_scale “false”.

[0313] 8. If the test is false then assign find_horizontal_scale “false”and find_vertical_scale “true” and exit the function.

[0314] 9. If find_horizontal_scale is true, then perform

[0315] AutoScaleHoirzScale:

[0316] 9.1 Based on the bounding box, narrow the search space for twovertical lines. Then using the narrowed dimension recalculate the besttwo vertical straight lines. Store the coordinates of the two verticallines to determine the scale.

[0317] 9.2 Select the horizontal edges falling within the two lines andalso within the bounding box.

[0318] 9.3 Search for horizontal edges and if there are no edges foundthen assign find_horizontal_scale “false” and find_vertical_scale“true”.

[0319] 9.4 If horizontal edges are found then perform the Houghtransform and determine the best fitting horizontal line. Store thecoordinates of the line.

[0320] 9.5 Calculate the coordinates of the intersecting points betweenhorizontal line and two vertical lines.

[0321] 9.6 Obtain pixel distance between two intersecting points.

[0322] 9.7 Using the true length of the scale, determine the LPR (truedistance in cm/pixel length).

[0323] 10. If find_vertical scale is true, then performAutoScaleHorizontalLines. This function performs the Hough transform todetermine the best two horizontal lines from the horizontal edge image,similar to AutoScaleVertLines.

[0324] 10.1 For each line select the longest edge in the horizontal edgeimage. Therefore, the final horizontal edge image will have only twohorizontal edge segments corresponding to each horizontal line and areexpected to represent the two most horizontal sides of the scale.

[0325] 10.2 Determine the centers of the two horizontal edges.

[0326] 10.3 Based on the maximum pixel limit determine a bounding boxisolating the two horizontal edges.

[0327] 10.4 Select all vertical edges falling within the selectedbounding box.

[0328] 11. Perform the following test:

[0329] 11.1 The vertical distance between the two centers of the twohorizontal edges is within a predetermined range of distance.

[0330] 11.2 The horizontal distance between the two centers of the twohorizontal edges is within a predetermined tolerance.

[0331] 11.3 At least one vertical edge should exist within the boundingbox.

[0332] 12. If the test fails return a fail value, e.g., 99999, forAutoScale fail.

[0333] AutoScaleVertScale

[0334] 1. Based on the bounding box, narrow the search space for twohorizontal lines. Then, using the narrowed dimensions in imagerecalculate the best two horizontal straight lines. Store thecoordinates of the two horizontal lines to determine the scale.

[0335] 2. Select the vertical edges falling within the two lines andalso within the bounding box.

[0336] 3. If there are no vertical edges found then return a fail value,e.g., 99999.

[0337] 4. If vertical edges are found, then perform the Hough transformand determine the best fitting vertical line. Store the coordinates ofthe line.

[0338] 5. Calculate the coordinates of the intersecting points betweenthe vertical line and two horizontal lines.

[0339] 6. Obtain pixel distance between two intersecting points.

[0340] 7. Using the true length of the scale, determine the LPR (truedistance in cm/pixel length).

[0341]FIG. 7 is a percentage-passing curve which shows the volumedistribution calculated from the manual tracing of the rock fragmentsand the volume distribution calculated using the system 10 of thepresent invention. It is apparent that the system 10 provides resultscomparable to the manual procedure without requiring any labor intensiveand time-consuming manual tasks.

[0342] The image processing system 14 generates an alarm to notify theoperator of any problems or faults in the system 10, such asunacceptable rock distribution, failure to read the rock scoopidentification tag, image brightness is below an acceptable threshold,the analysis cannot be performed for any reason, and the image is notavailable or cannot be found. The alarm may be in the form of an e-mailor a TCP/IP message sent by the rock fragmentation analysis system 10 toa remote PC. It is contemplated that the system 10 communicates theresults of the analysis and reasons for the generation of an alarm to acentral computer located in a remote location.

[0343] The rock fragmentation analysis system 10 of the invention isdesigned to operate on-line, i.e., while the mine, quarry, etc. is fullyfunctional. Preferably, the two or more processors provided within theimage processing system 14 distribute the processing load of the imageprocessing system 14.

[0344] While in accordance with the provisions of the statute, there areillustrated and described herein specific embodiments of the invention,those skilled in the art will understand that changes may be made in theform of the invention covered by the claims and that certain features ofthe invention may sometimes be used to advantage without a correspondinguse of the other features.

The embodiments of the invention in which an exclusive property orprivilege is claimed are defined as follows:
 1. A system for performingfragmentation analysis, the system comprising: a camera configured forcapturing a plurality of images of fragmented particles, wherein theplurality of images include at least two images for each group offragmented particles; and at least one processor for executingprogrammable instructions for generating at least one of a fragmentationdistribution of the fragmented particles corresponding to at least oneof the plurality of images, and a total fragmentation distribution ofthe fragmented particles corresponding to two or more of the pluralityof images.
 2. The system according to claim 1, further comprising: meansfor determining an orientation and a direction of travel for eachvehicle of a plurality of vehicles loaded with a respective group offragmented particles; and means for identifying each of the plurality ofvehicles.
 3. The system according to claim 2, wherein the means fordetermining an orientation and a direction of travel includes at leastone tag having a plurality of markers and mounted to each of theplurality of vehicles, and the means for identifying includes a subsetof the plurality of markers providing a respective identification codefor each of the plurality of vehicles.
 4. The system according to claim1, further comprising: means for scaling each of the plurality of imagesto locate side edges of a scale positioned in an image view of thecamera; and means for measuring a pixel distance between the side edgesto obtain a length to pixel ratio (LPR).
 5. The system according toclaim 4, wherein the means for scaling includes means for using a Houghtransformation method to determine a straight line passing through amaximum number of non-zero pixels in a binary image corresponding to atleast one of the plurality of images.
 6. The system according to claim1, wherein each of the plurality of images is a top view image of thefragmented particles.
 7. The system according to claim 1, furthercomprising: means for detecting entry of an object within a field ofview of the camera; and means for detecting exit of the object fromwithin the camera's field of view.
 8. The system according to claim 7,wherein the means for detecting entry of an object comprises: means fortaking two bands of pixels from the top and bottom of the camera's fieldof view; means for calculating the standard deviation of the intensityof red channel pixels within the two bands; means for comparing thecalculated standard deviation to a standard deviation of a blank image;and means for determining that the object has entered the camera's fieldof view if the calculated standard deviation is greater than thestandard deviation of the blank image.
 9. The system according to claim7, further comprising means for determining whether the object detectedas having entered the camera's field of view by the means for detectingentry is a vehicle.
 10. The system according to claim 9, wherein themeans for determining whether the object detected as having entered thecamera's field of view is a vehicle comprises means for determining ifan image representing the object within the camera's field of viewcontains an identification object by analyzing a binary imagecorresponding to the image.
 11. The system according to claim 1, furthercomprising: means for determining a region of interest (ROI) windowwithin each of the plurality of images; means for performing asegmentation process for the ROI window for generating a final blobimage for each of the plurality of images; and means for determining themajor and minor diameters of blobs in the blob image.
 12. The systemaccording to claim 11, wherein the means for performing a segmentationprocess comprises: means for separating blobs in a segmented gray scaleimage to produce a blob image; means for determining edges of thefragmented particles to produce a edge image; and means for combiningthe blob and edge images to produce the final blob image.
 13. The systemaccording to claim 11, wherein the at least one processor producesfragmentation results by using the major and minor diameters of blobs inthe blob image corresponding to each of the plurality of images.
 14. Thesystem according to claim 1, wherein the fragmentation distributions arevolume distributions of the fragmented particles.
 15. A method forperforming fragmentation analysis, the method comprising the steps of:capturing a plurality of images of fragmented particles, wherein theplurality of images include at least two images for each group offragmented particles; and executing programmable instructions forgenerating at least one of a fragmentation distribution of thefragmented particles corresponding to at least one of the plurality ofimages, and a total fragmentation distribution of the fragmentedparticles corresponding to two or more of the plurality of images. 16.The method according to claim 15, further comprising the steps of:determining an orientation and a direction of travel for each vehicle ofa plurality of vehicles loaded with a respective group of fragmentedparticles; and identifying each of the plurality of vehicles.
 17. Themethod according to claim 16, wherein the step of determining anorientation and a direction of travel includes the step of providing atleast one tag having a plurality of markers to each of the plurality ofvehicles, and the step of identifying each of the plurality of vehiclesincludes determining a respective identification code for each of theplurality of vehicles using a subset of the plurality of markers. 18.The method according to claim 15, further comprising the steps scalingeach of the plurality of images to locate side edges of a scalepositioned in an image view of the camera; and measuring a pixeldistance between the side edges to obtain a length to pixel ratio (LPR).19. The method according to claim 18, wherein the step of scalingincludes the step of using a Hough transformation method to determine astraight line passing through a maximum number of non-zero pixels in abinary image corresponding to at least one of the plurality of images.20. The method according to claim 15, wherein the step of capturing theplurality of images includes the step of providing a camera to capturetop view images of the fragmented particles.
 21. The method according toclaim 15, further comprising the steps of: detecting entry of an objectwithin a field of view of a camera positioned for capturing theplurality of images; and detecting exit of the object from within thecamera's field of view.
 22. The method according to claim 21, whereinthe step of detecting entry of an object comprises the steps of: takingtwo bands of pixels from the top and bottom of the camera's field ofview; calculating the standard deviation of the intensity of red channelpixels within the two bands; comparing the calculated standard deviationto a standard deviation of a blank image; and determining that theobject has entered the camera's field of view if the calculated standarddeviation is greater than the standard deviation of the blank image. 23.The method according to claim 21, further comprising the step ofdetermining whether the object detected as having entered the camera'sfield of view is a vehicle.
 24. The method according to claim 23,wherein the step of determining whether the object detected as havingentered the camera's field of view is a vehicle comprises the step ofdetermining if an image representing the object within the camera'sfield of view contains an identification object by analyzing a binaryimage corresponding to the image.
 25. The method according to claim 15,further comprising the steps of: determining a region of interest (ROI)window within each of the plurality of images; performing a segmentationprocess for the ROI window for generating a final blob image for each ofthe plurality of images; and determining the major and minor diametersof blobs in the blob image.
 26. The method according to claim 25,wherein the means for performing a segmentation process comprises thesteps of: separating blobs in a segmented gray scale image to produce ablob image; determining edges of the fragmented particles to produce aedge image; and combining the blob and edge images to produce the finalblob image.
 27. The method according to claim 25, further comprising thestep of producing fragmentation results by using the major and minordiameters of blobs in the blob image corresponding to each of theplurality of images.
 28. The method according to claim 15, wherein thefragmentation distributions are volume distributions of the fragmentedparticles.